Is there no library that handles this at the moment? There might not be, but would be nice to use if so

I think existing library opentelemetry_exporter is still dev status (not guaranteed to be stable)?

convert this into a with expression (almost all nested cases can become them)

is this still needed?

i don't think this will work w/o some statefulness (you need to keep around the last run date somewhere to compute the next run time, we do that everywhere in the db-bound crons).

A way to simulate that would be to convert this into a genserver, keep the last run time in genserver state, and only run the metrics export if the node is a determined leader (use the Console.ClusterRing module to determine that)

doing an enum.to_list eliminates the whole purpose of the stream (maintaining O(1) memory usage). What you should do here is instead pipe the concat'ed stream into Stream.chunk_every(100 or some other chunk size, and then pipe that to the exporter.

mostly a style nit, but i'd consider moving this metric formatting code to another module

i'd generally make these a with expression with {:ok, _} tuple matches down the line so you don't needlessly crash the genserver on bad input

don't worry about the transaction here, it's read-only so no need to roll back

can probably just make this |> then(&Logger.info("Exported #{&1} metrics to #{enpoint}"). It's not hard to no 0 metrics implies it didn't export

Transaction errors are silently swallowed

Repo.transaction/1 returns {:ok, result} or {:error, reason}, but the return value is discarded and do_export/1 unconditionally returns :ok. If the database transaction fails (connection error, lock timeout, etc.), there is no error log and the caller in handle_info(:export) still updates last_run_at as if the export succeeded — masking the failure entirely.

defp do_export(endpoint) do
  timestamp = DateTime.utc_now()

  result = Repo.transaction(fn ->
    []
    |> Stream.concat(MetricsBuilder.service_metrics_stream(timestamp))
    |> Stream.concat(MetricsBuilder.cluster_metrics_stream(timestamp))
    |> Stream.chunk_every(@chunk_size)
    |> Enum.reduce(0, fn chunk, count ->
      case Exporter.export(endpoint, chunk) do
        :ok -> count + length(chunk)
        {:error, reason} ->
          Logger.error("Failed to export chunk: #{inspect(reason)}")
          count
      end
    end)
    |> then(&Logger.info("Exported #{&1} metrics to #{endpoint}"))
  end)

  case result do
    {:ok, _} -> :ok
    {:error, reason} ->
      Logger.error("Metrics export transaction failed: #{inspect(reason)}")
      {:error, reason}
  end
end

And in handle_info(:export), only update last_run_at on :ok to allow a retry on the next schedule cycle.

check_ref field is never populated

State declares a check_ref field but :timer.send_interval/2 is called in init/1 without capturing its return value, so check_ref is always nil. The field is unused throughout the module and can be removed to avoid confusion.

Leader check skipped in :export handler

handle_info(:export, state) only checks whether a config is present — it does not verify that this node is still the leader. If :export is already in the process mailbox when handle_info(:check) cancels the timer due to a leadership change (the timer has already fired so Process.cancel_timer returns 0 but the message is still queued), the export will run on the non-leader node, producing duplicate metric data points.

Consider adding a leader guard:

def handle_info(:export, state) do
  case {leader?(), get_config()} do
    {true, {:ok, %{endpoint: endpoint}}} ->
      do_export(endpoint)
      {:noreply, %{state | last_run_at: DateTime.utc_now(), timer_ref: nil}}

    _ ->
      {:noreply, %{state | timer_ref: nil}}
  end
end

Stream.reject(&is_nil/1) is dead code

build_service_metric/2 always returns a %{name: ..., value: ..., ...} map and never returns nil, so this rejection step has no effect. It can safely be removed.